Method and system for scripting interactive animated actors

ABSTRACT

A system for the creation of real-time, behavior-based animated actors. The system provides tools to create actors that respond to users and to each other in real-time, with personalities and moods consistent with the author&#39;s goals and intentions. The system includes two subsystems. The first subsystem is an Animation Engine that uses procedural techniques to enable authors to create layered, continuous, non-repetitive motions and smooth transitions between them. The second subsystem is a Behavior Engine that enables authors to create sophisticated rules governing how actors communicate, change, and make decisions. The combined system provides an integrated set of tools for authoring the “minds” and “bodies” of interactive actors. The system uses an english-style scripting language so that creative experts who are not primarily programmers can create powerful interactive applications. The system allows authors of various abilities to create remarkably lifelike, responsively animated character interactions that can be run over networks in real time.

CROSS-REFERENCE TO A RELATED APPLICATION

This application is a continuation-in-part application of U.S. patentapplication Ser. No. 08/284,799 filed on Aug. 2, 1994, and U.S. patentapplication Ser. No. 08/511,737 filed on Aug. 7, 1995, and claimsbenefits of No. 60/023,052, filed Aug. 2, 1996. This application is alsoa 371 application of International Application No. PCT/US97/13664 filedon Aug. 1, 1997.

FIELD OF THE INVENTION

The present invention relates to a method and a system for creatingreal-time, behavior-based animated actors.

BACKGROUND INFORMATION

Cinema is a medium that can suspend disbelief. The audience enjoys thepsychological illusion that fictional characters have an internal life.When this is done properly, the characters can take the audience on acompelling emotional journey. Yet cinema is a linear medium; for anygiven film, the audience's journey is always the same. Likewise, theexperience is inevitably a passive one as the audience's reactions canhave no effect on the course of events.

This suspension of disbelief, or believability, does not necessarilyrequire a high degree of realism. For example, millions of people relateto Kermit the Frog and to Bugs Bunny as though they actually exist.Likewise, Bunraku puppet characters can create for their audience adeeply profound and moving psychological experience.

All of these media have one thing in common. Every moment of theaudience's journey is being guided by talented experts, whether ascreenwriter and actor/director, a writer/animator, or a playwright andteam of puppeteers. These experts use their judgment to maintain abalance: characters must be consistent and recognizable, and mustrespond to each other appropriately at all times. Otherwisebelievability is lost.

In contrast, many current computer games are non-linear, offeringvariation and interactivity. While it is possible to create charactersfor these games that convey a sense of psychological engagement, it isextremely difficult with existing tools.

One limitation is that there is no expert, actor, director, animator orpuppeteer, actually present during the unfolding drama, and so authorsusing existing techniques are limited by what they can anticipate andproduce in advance.

There have been several recent efforts to build network distributedautonomous agents. Work done by Steve Strassman in the area of “DesktopTheater” explored the use of expressive authoring tools for specifyinghow characters would respond to direction. (S. Strassman, DesktopTheater: Automatic Generation of Expressive Animation, PhD thesis, MITMedia Lab, June 1991.) This work, however, did not deal with real timevisual interaction.

The novel “Snow Crash” posits a “Metaverse,” a future version of theInternet which appears to its participants as a quasi-physical world.(N. Stephenson, Snow Crash Bantam Doubleday, New York, 1992.) Theparticipants are represented by fully articulate human figures, oravatars whose body movements are computed automatically by the system.“Snow Crash” touches on the importance of proper authoring tools foravatars, although it does not describe those tools.

The present invention takes these notions further, in that it supportsautonomous figures that do not directly represent any participant.

Several autonomous actor simulation systems have been developed whichfollow the parallel layered intelligence model illustrated in M. Minsky,Society of Mind, MIT press, 1986. Such a model was partially implementedby the subsumption architecture described by R. Brooks (A Robust LayeredControl for a Mobile Robot, IEEE Journal of Robotics and Automation,2(l):14-23, 1986) as well as by J. Bates et al. (Integrating Reactivity,Goals and Emotions in a Broad Agent, Proceedings of the 14th AnnualConference of the Cognitive 30 Science Society, Indiana, July 1992) andM. Johnson (WavesWorld: PhD Thesis, A Testbed for Three DimensionalSemi-Autonomous Animated Characters, MIT, 1994). Each of these systems,however, solve distinctly different problems than that of the presentinvention.

The “Jack” system described in N. Badler et al., Simulating Humans:Computer Graphics, Animation, and Control Oxford University Press, 1993focuses on proper task planning and biomechanical simulation. Thegeneral goal of that work is to produce accurate simulations ofbiomechanical robots. The simulations of Terzopoulis et. al (ArtificialFishes: Autonomous Locomotion, Perception, Behavior, and Leaming in aSimulated Physical World, Artificial Life, 1(4):327-351, 1994) haveautonomous animal behaviors that respond to their environment accordingto biomechanical rules. Autonomous figure animation has also beenstudied by N. Badler et al. (Making Them Move: Mechanics, Control, andAnimation of Articulated Figures Morgan Kaufmann Publishers, San Mateo,Calif., 1991), M. Girard et al. (Computational modeling for the computeranimation of legged figures, Computer Graphics, SIGGRAPH '85Proceedings, 20(3):263-270, 1985), C. Morawetz et al. (Goal-directedhuman animation of multiple movements, Proc. Graphics Interface, pages60-67, 1990) and K. Sims (Evolving virtual creatures, Computer Graphics,SIGGRAPH '94 Proceedings, 28(3):15-22, 1994).

The “Alive” system of P. Maes et al. (The Alive System: Full BodyInteraction with Autonomous Agents in Computer Animation '95 Conference,Switzerland, April 1995 IEEE Press, pages 11-18) focuses onself-organizing embodied agents which are capable of making inferencesand of learning from their experiences. Instead of maximizing theauthor's ability to express personality, the “Alive” system usesethological mechanisms to maximize the actor's ability to reorganize itsown personality, based on its own perception and accumulated experience.

In general, however, the above efforts do not focus on the author'spoint of view. To create rich interactive worlds inhabited by believableanimated actors, the need exists to provide authors with the propertools.

SUMMARY OF THE INVENTION

The present invention is directed to the problem of building believableanimated characters that respond to users and to each other inreal-time, with consistent personalities, properly changing moods andwithout mechanical repetition, while always maintaining the goals andintentions of the author.

An object of the method and system according to the present invention isto enable authors to construct various aspects of an interactiveapplication. The present invention provides tools which are intuitive touse, allow for the creation of rich, compelling content and producebehavior at run-time which is consistent with the author's vision andintentions. The animated actors are able to respond to a variety ofuser-interactions in ways that are both appropriate and non-repetitive.The present invention enables multiple actors to work together whilefaithfully carrying out the author's intentions, allowing the author tocontrol the choices the actors make and how the actors move theirbodies. As such, the system of the present invention provides anintegrated set of tools for authoring the “minds” and “bodies” ofinteractive actors.

In accordance with an embodiment of the present invention, animatedactors follow scripts, sets of author-defined rules governing theirbehavior, which are used to determine the appropriate animated actionsto perform at any given time. The system of the present invention alsoincludes a behavioral architecture that supports author-directed,multi-actor coordination as well as run-time control of actor behaviorfor the creation of user-directed actors or avatars. The system uses aplain-language, or “english-style” scripting language and a networkdistribution model to enable creative experts, who are not primarilyprogrammers, to create powerful interactive applications.

The present invention provides a method and system for manipulating thegeometry of one or more animated characters displayed in real-time inaccordance with an actor behavior model. The present invention employsan actor behavior model similar to that proposed by B. Blumberg et al.,Multi-Level Direction of Autonomous Creatures for Real-Time VirtualEnvironments Computer Graphics (SIGGRAPH '95 Proceedings), 30(3):47-54,1995.

The system of the present invention comprises two subsystems. The firstsubsystem is an Animation Engine that uses procedural techniques toenable authors to create layered, continuous, non-repetitive motions andsmooth transitions between motions. The Animation Engine utilizesdescriptions of atomic animated actions (such as walk or wave) tomanipulate the geometry of the animated actor.

The second subsystem is a Behavior Engine that enables authors to createsophisticated rules governing how actors communicate, change, and makedecisions. The Behavior Engine is responsible for both higher-levelcapabilities (such as going to the store or engaging another actor in aconversation) and determining which animations to trigger. The BehaviorEngine also maintains the internal model of the actor, representingvarious aspects of an actor's moods, goals and personality. The BehaviorEngine constitutes the “mind” of the actor. At run-time, an actor'smovements and behavior are computed by iterating an “update cycle” thatalternates between the Animation and Behavior Engines.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 shows a block diagram of the behavior model of an animated actor,in accordance with the present invention.

FIG. 2 illustrates the flexing of a deformable mesh.

FIG. 3 illustrates the use of a buffering action.

FIG. 4 shows a block diagram of the behavior model of an animated actorincluding a blackboard for communication with other actors.

FIG. 5 shows a block diagram of the behavior model of an animated actorincluding a user interface allowing users to interact with the actor atdifferent semantic levels.

FIG. 6 shows a block diagram of a model for distributing components ofthe system of the present invention over a Wide Area Network.

FIGS. 7a and 7 b illustrate two renderings of the same animated actorperforming the same action.

DETAILED DESCRIPTION

FIG. 1 is a block diagram of a behavior model describing the majorfunctional components of an animated actor's behavior. As shown in FIG.1, the behavior model comprises a geometry model 10 that is manipulatedin real-time, an Animation Engine 20 which utilizes descriptions ofatomic animated actions (such as “walk” or “wave”) to manipulate thegeometry, and a Behavior Engine 30 which is responsible for higher-levelcapabilities, such as “going to the store,” or engaging another actor ina conversation, and decisions about which animations to trigger. Inaddition, the Behavior Engine 30 maintains the internal model of theactor, representing various aspects of the actor's moods, goals andpersonality. In essence, the Behavior Engine 30 constitutes the “mind”of the actor, whereas the Animation Engine constitutes the “body” of theactor.

At run-time, an actor's movements and behavior are computed by iteratingan update cycle that alternates between the Animation and BehaviorEngines.

The Animation Engine 20 provides tools for manipulating the geometry 10by generating and interactively blending realistic gestures and motions.The Animation Engine controls the body of the actor. Actors are able tomove from one animated motion to another in a smooth and natural fashionin real time. The motions can be layered and blended to convey differentmoods and personalities. Such an Animation Engine is described in U.S.patent application Ser. No. 08/234,799, filed Aug. 2, 1994, entitledGESTURE SYNTHESIZER FOR IMAGE ANIMATION, and incorporated herein byreference in its entirety, and U.S. patent application Ser. No.08/511,737, filed Aug. 7, 1995, entitled COMPUTER GENERATED INTERACTIONOF CHARACTERS IN IMAGE ANIMATION, and incorporated herein by referencein its entirety.

Using the geometric model 10, an author is able to build any of avariety of articulated characters. Actors can be given the form ofhumans, animals, animated objects or imaginary creatures. The geometricmodel of an actor consists of parts that are connected by rotationaljoints. The model can be deformable, which is useful for muscle flexingor facial expressions. Such deformation is illustrated in FIG. 2. Amethod which can be used in conjunction with the present invention forgenerating such deformations in animated actors is described in J.Chadwick et al., Layered construction for deformable animatedcharacters. Computer Graphics (SIGGRAPH '89 Proceedings), 23(3):243-252,1989 89.

An author can specify individual actions in terms of how those actionscause changes over time to each individual degree of freedom (DOF) inthe model. The system then combines these DOF values to make smoothtransitions and layerings among actions.

There are various types of DOFs that an author can control. The simplestare the three rotational axes between any two connected parts of thegeometric model 10. Examples of actions involving such DOFs are headturning and knee bending.

The author can also position a part, such as a hand or a foot.

The system automatically does the necessary inverse kinematics topreserve the kinematic chain. From the author's point of view, the x,y,zcoordinates of the part are each directly available as a DOF.

The author can also specify part mesh deformations as DOFs. To make adeformation, the author provides a “deformation target,” a version ofthe model (or just some parts of the model) in which some vertices havebeen moved. For each deformation target, the system detects whichvertices have been moved, and builds a data structure containing thex,y,z displacement for each such vertex. For example, if the authorprovides a smiling face as a deformation target, he can then declareSMILE to be a DOF. The author can then specify various values for SMILEbetween 0 (no smile) and 1 (full smile). The system handles thenecessary interpolation between mesh vertices. In the particular case ofsmiling, the author can also specify negative values for SMILE, to makethe face frown.

In accordance with the present invention, the author defines an actionas a list of DOFs, together with a range and a time-varying expressionfor each DOF. Most actions are constructed by varying a few DOFs overtime via combinations of sine, cosine and coherent noise. For example,sine and cosine signals are used together within actions to impartelliptical rotations.

Coherent noise is used in the method and system of the present inventionto enhance realism. Using noise in limb movements allows authors to givethe impression of naturalistic motions without the need to incorporatecomplex simulation models. Coherent noise can be used to convey thesmall motions of a character trying to maintain balance, the controlledrandomness of eye blinking, or the way a character's gaze wanders arounda room. Although in real life each of these examples has a differentunderlying mechanism, viewers do not perceive the mechanism itself butrather perceive some statistics of the motion produced by the mechanism.When coherent noise is applied in a way that matches those statistics,the actor's movements are believable. Use of noise to produce realisticanimated motion is described in U.S. patent application Ser. No.08/234,799, filed Aug. 2, 1994, entitled GESTURE SYNTHESIZER FOR IMAGEANIMATION, and incorporated herein by reference in its entirety, and inU.S. patent application Ser. No. 08/511,737, filed Aug. 7, 1995,entitled COMPUTER GENERATED INTERACTION OF CHARACTERS IN IMAGEANIMATION, and incorporated herein by reference in its entirety.

The author can also import keyframed animation from commercial modelingsystems such as Alias or SoftImage. The system internally converts theseinto actions that specify time varying values for various DOF'S. To therest of the system, these imported actions look identical to any otheraction.

In accordance with the present invention, an author uses DOFs to buildactions. An exemplary syntax for expressing actions will now bedescribed.

In each line of an action, a body part name is followed first by threeangular intervals, and then by three time-varying interpolants inbraces. Expressions for three exemplary hand waving actions, which anactor might perform as gestures while talking, for example, are asfollows:

define ACTION “Talk Gesture1” { R_UP_ARM 25:55 0 −35:65 {N0 0 N0}R_LO_ARM 55:95 0 0 {N1 0 0} R_HAND −40:25 75:−25 120 {N1 N2 0} } defineACTION “Talk Gesture2” { R_UP_ARM 10:47 0 −10:45 {N0 0 N0} R_LO_ARM35:77 0 0 {N1 0 0} R_HAND −53:55 −40:15 120 {N1 N2 0 } } define ACTION“Talk-Gesture3” { R_UP_ARM 45 20:15 0 {0 N0 N0} R_LO_ARM 70:120 0 0 {N10 0} R HAND 40:15 0 120 {N2 0 0 } }

Each interpolant is used to compute a single angle in its correspondinginterval. The results are applied to the corresponding part as pitch,roll and yaw rotations respectively. The angle intervals are constantover time, whereas the time varying interpolants are reevaluated at eachupdate cycle. For example, in the first line of the “Talk Gesturel”action above, if NO has the value 0.5 at some time step, then theresulting pitch rotation at that time step will be 40 degrees, 0.5 ofthe way between 25 degrees and 55 degrees.

Each one of the above expressions uses several frequencies of noise tomodulate arm movement. The first two are general hand waving gestures,while the third shakes the arm more emphatically, as though pointing atthe listener. The variables N0, N1, and N2 are shorthand that the systemprovides the author to denote time varying coherent noise signals ofdifferent frequencies. For instance, N1 is one octave higher than N0,and N2 is one octave higher than N1. The value of each noise signalvaries between 0.0 and 1.0.

Note that in the exemplary talk gestures listed above, the upper armmovement is controlled by N0, whereas the lower arm movement iscontrolled by N1. The result is that the upper arm will, on average,swing back and forth about the shoulder once per second, whereas thelower arm will, on average swing back and forth about the elbow twiceper second. At the same time, the hand, which is controlled by N2, makessmall rapid rotations about the wrist. Although many combinations offrequencies can be used, the exemplary frequency combination discussedimparts motion that appears natural. Presumably, the 2:1 frequency ratioreflects the fact that the lower arm has about half the mass of thetotal arm and thus tends to swing back and forth about twice asfrequently.

Animated actors generated in accordance with the present invention cando many things at once and these simultaneous activities can interact indifferent ways. For example, an author may want an actor who is wavingto momentarily scratch his head with the same hand. It would beincorrect for the waving movement to continue during the time the actoris scratching his head. The result could be strange. For example, theactor might try feebly to wave his arm while making vague scratchingmotions about his head. In this case, it is desirable to decrease theamount of waving activity as the amount of scratching activityincreases. In other words, some sort of ease-in/out transition betweenmotions is needed.

However, if the author wants an actor to scratch his head for a momentwhile walking downstage, it would be incorrect if the system were toforce the actor to stop walking every time he scratched his head. Inthis case, an ease-in/out transition would be inappropriate.

The difference between the aforementioned examples is that the formersituation involves two actions which cannot coexist, whereas the lattersituation involves two actions that can gracefully coexist. The presentinvention provides a mechanism which allows an author, in an easy andunambiguous way, to make distinctions between actions which cannotcoexist and actions that can gracefully coexist. To accomplish this, thesystem employs a set of rules.

Motion can be treated as being layered, analogously to composited imageswhich can be layered back to front. However, whereas an image mapspixels to colors, an action maps DOFs to values. The system of thepresent invention allows an author to place actions in different groups,which groups are organized in a “back-to-front” order. Also, the systemallows the author to “select” any action.

Given this structure, the system of the present invention follows thefollowing compositing rules:

1) Actions which are in the same group compete with each other. At anymoment, every action possesses some weight, or opacity. When an actionis selected, its weight transitions smoothly from zero to one.Meanwhile, the weights of all other actions in the same group transitionsmoothly down to zero.

2) Actions in groups which are further forward obscure those in groupswhich are further back.

In accordance with the present invention, actions which compete witheach other should be placed by the author in the same group. Someactions, such as walking, are fairly global in that they involve manyDOFs throughout the body. Others, such as head scratching, are fairlylocalized and involve relatively few DOFs. The author should place moreglobal actions in the rear-most groups. More localized actions should beplaced in front of the global actions. Also, some actions are relativelypersistent, while others are generally done fleetingly. Groups of veryfleeting or temporary action (such as scratching or coughing) should beplaced still further in front.

For the author, the present invention makes it easy to specifyintuitively reasonable action relationships. For example, suppose theauthor specifies the following action grouping:

GROUP Stances ACTION Stand ACTION Walk GROUP Gestures ACTION No_wavingACTION Wave_left ACTION Wave_right GROUP Momentary ACTION No_scratchingACTION Scratch_head_left

After standing, the actor will start to walk. While continuing to walkhe will wave with his left hand. Then he will scratch his head with hisleft hand, and resume waving again. Finally, he will switch over towaving with his right hand.

The grouping structure of the present invention allows the author toeasily impart to the actor many behavioral rules. For example, given theabove exemplary action groupings, the actor “knows” to wave with eitherone hand or the other but not both at once. The actor also “knows” hedoesn't need to stop walking in order to wave or to scratch his head and“knows” that after he's done scratching he can resume whatever else hewas doing with that arm.

At any animation frame, the run-time system must assign a unique valueto each DOF for the model, then move the model into place and render it.The procedure for computing these DOFs will now be described. Withineach group, a weighted sum is taken over the contribution of each actionto each DOF. The values for all DOFs in every group are then composited,proceeding from back to front. The result is a single value for eachDOF, which is then used to move the model into place. This algorithmshould also correctly composite inverse kinematic DOFs over directrotational DOFs. DOF compositing is described in U.S. patent applicationSer. No. 08/234,799, filed Aug. 2, 1994, and entitled GESTURESYNTHESIZER FOR IMAGE ANIMATION, which is incorporated herein byreference in its entirety, and in U.S. patent application Ser. No.08/511,737, filed Aug. 7, 1995, and entitled COMPUTER GENERATEDINTERACTION OF CHARACTERS IN IMAGE ANIMATION, which is incorporatedherein by reference in its entirety.

The system of the present invention provides the author with tools toeasily synchronize movements of the same DOF across actions. Transitionsbetween actions that must have different tempos are handled using amorphing approach. During the time of the transition, the speed of amaster clock is continuously varied from the first tempo to the secondtempo, so that the phases of the two actions are always aligned. Similartechniques are described in A. Bruderlin et al., Motion SignalProcessing, Computer Graphics (SIGGRAPH '95 Proceedings), 30(3):97-104,1995 and A. Witkin et al., Motion Warping, Computer Graphics (SIGGRAPH'95 Proceedings), 30(3):105-108, 1995.

When it would be awkward for an actor to make a direct transitionbetween two particular actions in a group, the system allows the authorto insert a buffering action. For example, suppose an actor transitionsfrom having his hands behind his back to crossing his arms over hischest. Because DOFs are combined linearly, the actor would pass hishands through his body. The system of the present invention allows theauthor to avoid such situations by declaring that some action in a groupcan be a buffering action for another. This is implemented by building afinite state machine that forces the actor to pass through thisbuffering action when entering or leaving the troublesome action.

For example, if the author declares hands-at-the-sides as a bufferingaction for hands-behind-the-back, when the actor transitions betweenhands-behind-the-back and any other action, he will always first movehis hands around the sides of his body. This series of movements isillustrated in FIG. 3.

With the method and system of the present invention, one or more userscan interact with the animated actors in real time. As such, theunpredictable involvement of a live user in the run-time system does notallow the author to create deterministic scenarios. The user's actionsand responses are implicitly presenting the actor with a choice of whatto do next. Because of this variability, the user's experience of anactor's personality and mood must be conveyed largely by that actor'sprobability of selecting one choice over another.

As a simple example, suppose the user often goes away for a while andkeeps an actor waiting for various amounts of time. If the actor usuallysits down or naps before the user returns, then the actor will appear tothe user as a lazy or tired character. The user thus forms an impressionbased on probabilities.

The influence of the author lies in carefully tuning such probabilities.A goal of the Behavior Engine is to help the author in the mostexpressive way possible.

In accordance with the present invention, the Behavior Engine providesseveral authoring tools for guiding an actor's behavioral choices. Themost basic tool is a simple parallel scripting system. Generallyspeaking, at any given moment, an actor will be executing a number ofscripts in parallel. In each of these scripts, the most common operationis to select one item from a list of items. These items are usuallyother scripts or actions for the actor (or for some other actor) toperform.

The Behavior Engine in accordance with the present invention providesthe author with “probability shaping” tools for guiding an actor'schoices. The more expressive the tools for shaping these probabilities,the more believable the actors will be.

The operation of the Behavior Engine will now be described, startingwith a description of the basic parallel scripting structure followed bya description of the probability shaping tools.

In accordance with the present invention, actions are the mechanism forthe continuous control of the movements made by an actor's body. Scriptsare provided as a mechanism for the discrete control of the decisionsmade by the actor's mind.

It is to be assumed that the user will be making unexpected responses.For this reason, it is not sufficient to provide the author with a toolfor scripting long linear sequences. Rather, the system of the presentinvention allows the author to create layers of choices, from moreglobal and slowly changing plans, to more localized and rapidly changingactivities, that take into account the continuously changing state ofthe actor's environment, and the unexpected behavior of the humanparticipant.

Like actions, the system of the present invention allows the author toorganize scripts into groups. However, unlike actions, when a scriptwithin a group is selected, any other script that was running in thesame group immediately stops. In any group at any given moment, exactlyone script is running.

Generally, the author should organize into the same group those scriptsthat represent alternative modes that an actor can be in at some levelof abstraction. For example, the group of activities that an actorperforms during his day might be:

ACTIVITIES Resting Working Dining Conversing Performing

In general, the author first specifies those groups of scripts thatcontrol longer term goals and plans. These tend to change slowly overtime, and their effects are generally not immediately felt by the user.

The last scripts are generally those that are most physical. They tendto include actual body actions, in response to a user's actions and tothe state of higher level scripts. For example, the behavior model of anactor might contain the following groups of scripts, in order, within alarger set of scripts:

. . . DAY-PLANS Waking Morning Lunch Afternoon Dinner Evening . . .ACTIVITIES Resting Working Dining Conversing Performing . . . BEHAVIORSleeping Eating Talking Joking Arguing Listening Dancing

The Animation Engine, with its groups of continuous actions, can bethought of as an extension of this grouping structure to even lowersemantic levels.

A script is organized as a sequence of clauses. At runtime, the systemruns the clauses sequentially for the selected script in each group. Atany update cycle, the system may run the same clause that it ran in theprevious cycle, or it may move on to the next clause. The author isprovided with tools to “hold” clauses in response to events or timeouts.

The two primary functions of a script clause are: 1) to trigger otheractions or scripts and 2) to check, create or modify the actor'sproperties.

The simplest thing an author can do within a script clause is to triggera specific action or script, which is useful when the author has aspecific sequence of activities that he wants the actor to perform. Inthe following script example, the actor walks onstage, turns to thecamera, bows, and then walks offstage again.

define SCRIPT “Curtain Call” {“walk to center”} {continue until { mylocation equals center } } {“turn to camera”} {continue until { “turn tocamera” is done } } {“bow” } {continue for 3 seconds} {“walk offstage”}

In this case, phrases in quotes represent scripts or actions. Each ofthese scripts might, in turn, call other scripts and/or actions. Theother information (continue, etc.) is used to control the timing of thescene.

Through layering, an author can create complex behaviors from simplerscripts and actions, as illustrated by the following example:

define SCRIPT “greeting” { {“enter”} {wait 4 seconds} {“turn to camera”}{wait 1 second} {“wave” for 2 seconds “talk” for 6 seconds } {wait 3seconds} {“sit”} {wait 5 seconds} {“bow” toward “Camera”} {wait 2seconds} {“leave”} }

In this example, the “enter” script is activated first. The “enter”script, can for example, cause the actor to walk to center stage. The“enter” script and “greeting” script are now running in parallel. The“greeting” script waits four seconds before activating the “turn tocamera” script. This tells the actor to turn to face the specifiedtarget, which in this case is the camera. The “greeting” script thenwaits one second, before instructing the actor to begin the “wave” and“talk” actions. The script waits another 3 seconds before activating the“sit” action during which time the “wave” action has ended, returning tothe default “No Hand Gesture” action in its group. Meanwhile, the “talk”action continues for another three seconds after the actor sits. Twoseconds later, the actor bows to the camera, waits another two secondsand then leaves.

In addition to commands that explicitly trigger specific actions andscripts, the present invention provides a number of tools for generatingthe more non-deterministic behavior required for interactive non-linearapplications. An author may specify that an actor choose randomly from aset of actions or scripts, as in the following example:

SCRIPT “Rock Paper Scissors” {choose from {“Rock” “Paper” “Scissors”}}

Once an action or script is chosen, it is executed as though it had beenexplicitly specified.

Alternately, the author can specify weights associated with each item inthe choice. These weights are used to affect the probability of eachitem being chosen, as in the following example:

define SCRIPT “Rock Paper Scissors 2” {choose from {“Rock” .5 “Paper” .3“Scissors” .1}}

In this case, there is a 5/9 chance the actor executing this script willchoose the “Rock” action, a 3/9 chance that the actor will choose the“Paper” action, and a 1/9 chance that the actor will pick the “Scissors”action. The decision is still random, but the author has specified adistinct preference for certain behaviors over others.

To enhance the realism of characters, the method and system of thepresent invention allows the author to have an actor's decisions reflectthe actor's mental state and the state of the actor's environment. Anactor's decision about what to do may depend on any number of factors,including mood, time of day, which other actors are in proximity andwhat they're doing, what the user is doing, etc.

The present invention allows authors to create decision rules which takeinformation about an actor and his environment and use this to determinethe actor's tendencies toward certain choices over others. In accordancewith the present invention, the author can specify what information isrelevant to the decision and how this information influences the weightassociated with each choice. As this information changes, the actor'stendency to make certain choices over others will change as well.

The information about an actor and his relationship to his environmentare stored in the system as an actor's properties. These properties maybe used to describe aspects of an actor's personality such asassertiveness, temperament or dexterity, an actor's current mood such ashappiness or alertness, or his relationship to other actors or objectssuch as his sympathy toward the user or his attitude about dealing witha particular object. These properties can be specified by the authoreither when the actor is created, or within a clause of a script, toreflect a change in the actor due to some action or event. The lattercase is illustrated in the following example:

define SCRIPT “Eat Dinner” {“Eat”} {set my “Appetite” to 0} {“Belch”}

In this case, the author specifies how the actor's behavior is reflectedin his personality by reducing the actor's appetite after eating.

An author can also use properties to provide information about anyaspect of an actor's environment, including inanimate props and sceneryand even the scripts and actions an actor chooses from. The author canassign properties to actions and scripts describing the various semanticinformation associated with them, such as aggressiveness, formality,etc. The author can then use these values in the construction ofdecision rules. Decision rules allow actors to make decisions thatreflect the state of the world the author has created.

When a decision rule is invoked, a list of objects is passed to it. Thesystem then uses the decision rule to generate a weight between zero andone for each object. This list can then be used to generate a weighteddecision.

Each decision rule consists of a list of author-specified factors, i.e.,pieces of information that will influence the actor's decision. Each ofthese factors is assigned a weight which the author uses to control howmuch influence that piece of information has upon the decision. Thisinformation can simply be the value of a property of an object as in thefollowing example:

{choose from {“Steph” “Bob” “Sarah”} based on “who's interesting”}define DECISION-RULE “who's interesting” factor {his/her “Charisma”}influence .8 factor {his/her “Intelligence”} influence .2

In this example, the decision rule will use the “Charisma” and“Intelligence” properties of the three actors to generate a weight foreach actor that will be used in the decision. In this case, the authorhas specified that the value of an actor's “Charisma” will have thegreatest influence in determining that weight, whereas the value of anactor's “Intelligence” will have a lesser influence. The influence isoptional and defaults to 1.0 if unspecified.

When an object is passed through a decision rule, a weighted sum is madeof each of the values returned from the associated factors, modified bythe scale assigned to the set of choices. This becomes the final weightassigned to the object that is used in making the decision.

The final weight is determined in accordance with the followingequation:

FinalWeight=Scale(f1^(il) f2^(i2) . . . fn ^(in))

where:

f1, f2 . . . fn are factors 1, 2, . . . n, and

i1, i2 . . . in are influences 1, 2, . . . n.

An author can also use the relationship between the actor and thevarious choices to influence a decision, by making “fuzzy” comparisonsbetween their properties. For example:

{choose from {“Fight” “Flee”} based on “how courageous”} defineDECISION-RULE: “how courageous” { factor {my “Courage” equals its“Courage Level” to within 0.5} }

In this example, the author is comparing the actor's “Courage” propertywith the “Courage Level” property associated with the scripts “Fight”and “Flee”. If the actor's “Courage” equals the script's “CourageLevel,” the decision rule will assign a weight of 1 to that choice. Ifthe values are not equal, a weight between 0 and 1 will be assignedbased on the difference between them, dropping to 0 when the differenceis greater than the “within” range, in this case, 0.5. As the actor's“Courage” increases or decreases, so will the actor's tendency towardone option or the other.

A fuzzy comparison such as that described above, entails comparing howclose an Input Value comes to a Target Value (or Target Range). Theresult of the comparison is 1 if the Input Value is at the Target Value(or within the Target Range), and drops to 0 at a distance of Spreadfrom the TargetValue. The fuzzy comparison is implemented as follows:

y=w(¦InputValue−TargetValue¦/Spread),

where:

y is the Fuzzy Value, and

w is a bell curve weighting kernel.

A raised cosine function can be used for the bell curve weightingkernel, w. A high and low spread may be specified, in which case inputvalues greater than the target value (or range) will use the high spreadin the calculation, while input values lower than the target value (orrange) will apply the low spread.

The returned value is then modified based on the type of fuzzy operationas follows:

equals y Value not equals 1-y, its complement greater than y, highspread defaults to infinity not greater than 1-y, high spread defaultsto infinity less than y, low spread defaults to  -infinity not less than1-y, low spread defaults to  -infinity

An author may want an actor to choose from a set of options usingdifferent factors to judge different kinds of items. A list of objectspassed to the decision rule may be divided into subsets usingauthor-defined criteria for inclusion. The weights assigned to a givensubset may be scaled, reflecting a preference for an entire group ofchoices over another. For example:

{choose from (“Steph” “Bob” “Sarah”) based on “who's interesting2”}define DECISION-RULE: “who's interesting2” { subset “Those I'd beattracted to” scale 1 factor {his/her “Intelligence” equals my“Confidence” to within .4} subset “Those I wouldn't be attracted to”scale .8 factor {his/her “Intelligence” equals my “Intelligence” towithin .4} } define SUBSET: “Those I'd be attracted to” {his/her“Gender” equals my “Preferred Gender”} define SUBSET: “Those I wouldn'tbe attracted to” {his/her “Gender” does not equal my “Preferred Gender”

Let's assume the actor is considered a heterosexual male (i.e. his“Gender” is “Male” and his “Preferred Gender” is “Female”). The weightassigned to “Steph” and “Sarah” will depend on how closely theirintelligence matches our actor's confidence (i.e., being put off by lessintelligent women and intimidated by more intelligent ones). The factorused to judge “Bob” reflects a sympathy toward men who are hisintellectual equal, unaffected by the actor's confidence. The scalevalues reflect a general preference for one gender over the other.

It is desirable to give an author the same control over groups of actorsthat he has over individual actors. The preferred model is that theauthor is a director who can direct the drama via pre-written behaviorrules. To the author, all of the actors constitute a coordinated “cast”,which in some sense is a single actor that happens to have multiplebodies.

For this reason, the system of the present invention allows actors tomodify each other's properties with the same freedom with which an actorcan modify his own properties. From the author's point of view, this ispart of a single larger problem of authoring dramatically responsivegroup behavior. For example, if one actor tells a joke, the author maywant the other actors to respond, favorably or not, to the punchline. Byhaving the joke teller cue the other actors to respond, proper timing ismaintained, even if the individual actors make their own decisions abouthow exactly to react. In this way, an actor can give the impression ofalways knowing what other actors are doing and respond immediately andappropriately in ways that fulfill the author's goals.

This communication occurs through the use of a shared blackboard, asillustrated in the architectural block diagram of FIG. 4. The blackboard40 allows the actors to be coordinated, whether running on a singleprocessor, on multiple processors or even across a network.

The author can also include user-interface specifications in an actor'sscripts. For example, the system can generate widgets at run-time inresponse to the actor's behavior or to serve the needs of the currentscene or interaction. The user can employ these widgets to triggeractions and scripts at any level of the actor's behavioral hierarchy.Directing the actions of one or more animated actors enables users toenter the virtual environment. By making this interface a scriptableelement, the present invention enables authors to more easilychoreograph the interaction between the virtual actors and humanparticipants.

A feature of the present invention is the ability to provide userinteraction with the system at different semantic levels. This abilityis illustrated in FIG. 5 which shows the behavioral model of an animatedactor including a user interface 50. The user interface 50 allows a userto interact with both the Behavior Engine 30 and Animation Engine 20 ofan animated actor. The result of a user's actions can cause changes inthe system anywhere from high level scripts to low level actions. Thesystem of the present invention allows the author to give the user theright kind of control for every situation. If the user requires a veryfine control over the actors' motor skills, the system allows the authorto provide the user with direct access to the action level. On the otherhand, as when the user is involved in a conversation with an actor, thesystem allows the author to let the user specify a set of gestures forthe actor to use, but have the actor decide on the specific gesturesfrom moment to moment. At an even higher level, the author may want tohave the user directing large groups of actors, such as an actingcompany or an army, in which case he might have the user give the entiregroup directions and leave it to the individual actors to carry outthose instructions. Since any level of the actor's behavior can be madeaccessible to the user, the author is free to vary the level of controlat any point in the application.

Many authors and artists interested in creating interactive content arenot primarily programmers. As such, the present invention provides anumber of “english-style” scripting language extensions that make iteasier for authors and artists to begin scripting interactive scenarios.

The scripting language is written as an extension of the systemlanguage. Thus, as users become more experienced they can easily migratefrom scripting entirely using the high-level english-style syntax toextending the system through low-level algorithmic control.

The system of the present invention can be distributed over a network.An exemplary embodiment of a system in accordance with the presentinvention is implemented as a set of distributed programs in UNIX,connected by TCP/IP socket connections, multicast protocols and UNIXpipes. The participating processes can be running on any UNIX machines.This transport layer is hidden from the author.

All communication between participant processes is done by continuallysending and receiving programs around the network. These are immediatelyparsed into byte code and executed. At the top of the communicationstructure are routing processes. There must be at least one routingprocess on every participating Local Area Network. The router relaysinformation among actors and renderer processes. For Wide Area Network(WAN) communication, the router opens sockets to routers at other LANs.

In an exemplary embodiment, each actor maintains a complete copy of theblackboard information for all actors. If an actor's behavior statechanges between the beginning and end of a time step, the changes arerouted to all other actors.

Typical WAN latencies, however, can be several seconds. This poses aproblem for two virtual actors interacting over a distributed system.From the viewpoint of believability, some latency is acceptable for highlevel decisions but not for low level physical actions. For example,when one character waves at another, the second character can get awaywith pausing for a moment before responding. But two characters who areshaking hands cannot allow their respective hands to move through spaceindependently of each other. The hands must be synchronized to at leastthe animation frame rate.

The blackboard model makes it possible to deal with this situationgracefully. In an exemplary embodiment, the Behavior Engine and theAnimation Engine for an actor can be split across a WAN. The Behaviorand Animation Engines can communicate with each other through theblackboard. For the DOFs produced by the Animation Engine, theblackboard is allowed to contain different values at each LAN. For thestates produced by the Behavior Engine, the actor maintains a singleglobal blackboard.

Computationally, the Behavior Engine for each actor runs at only asingle LAN, whereas the Animation Engine runs at each LAN. When twocharacters must physically coordinate with each other, they use thelocal versions of their DOFs. In this way, an actor is always in asingle Behavioral State everywhere on the WAN, even though at each LANhe might appear to be in a slightly different position. In a sense, theactor has one mind, but multiple bodies.

This distributed arrangement is illustrated in FIG. 6 which shows ablock diagram of a Wide Area Network distribution model for an exemplaryembodiment of the system of the present invention. In the configurationof FIG. 6, a WAN 100 links three LANs 101, 102 and 103, in a knownmanner. The WAN 100 can be the world wide web, for example. On each LAN,one “mind”, or Behavior Engine is executed for one of three animatedcharacters, whereas separate “bodies”, or Animation Engines, areexecuted for each of the three characters on each of the three LANs. Thevarious body renderings of an actor inhabit a parallel universe.Although these bodies may differ slightly in their position within theirown universe, they are all consistent with the actor's single mind.

This leads to an interesting property. Suppose that an actor is dancingwhile balancing a tray in a particular scene. Further, suppose that thescene is being watched at the same time by users in Sao Paulo, Brazil,and in Manhattan, N.Y., with a connection over the Internet. Perhapssome of the users are interacting with the actor. In this scene, theactor's Behavior Engine makes all the choices about whether to dance,whether to keep balancing the tray, how much joy and abandon versusself-conscious restraint he puts into the dance, etc. The actor'sAnimation Engine sets all the DOFs that determine how he moves whendoing these things, so that they remain responsive and coordinated.

If the viewers in New York and those in Sao Paulo are talking on thetelephone, they will report seeing the same thing. Yet, if a high speeddedicated video link were established and participants could see the tworenderings of the actor side by side, they would see two somewhatdifferent animations, for example, as shown in FIGS. 7a and 7 b. In one,the actor's hand might thrust up to balance the tray half a secondsooner, in the other he might have his other arm extended a bit furtherout. He might be rocking right to left in one screen, while he isrocking from left to right in the other.

Thus, while there may be only one such actor with the behavior describedabove—with his mood, his personality, and engaged in that particulartask—the same actor can have many, slightly different physicalrealities, differing only up to the threshold where they might disruptthe social unity of his Behavioral State.

If communication lag exceeds several seconds, significant differencesmay have occurred between the various instances of the actor. Forexample, suppose two actors that are temporarily out of communicationeach try to pick up some physical object. One reliable solution to thiscollaborative work dilemma is to make the object itself an actor.Furthermore, the object itself must agree to be picked up, since it toomust maintain a consistent physical reality.

The blackboard protocol has a great advantage in terms of flexibility.To take full advantage of this flexibility, a support library that givesaccess to the blackboard is provided in an embodiment of the system ofthe present invention. The support library can be written in a knownprogramming language such as C. This allows authors unfamiliar with thesystem of the present invention, except for the names of actions andscripts, to immediately begin to control virtual actors.

For example, a researcher can write a standalone C program that linkswith the support library. The program can pass string arguments such as“Gregor Sit” or “Otto Walk-To-Door” to an output function. In thismanner, the standalone program can modify actors' behavior states.

Because the system treats the standalone program as just another actor,the program can also listen for messages by calling an input routine.These messages contain the information that updates the blackboard withthe actors' locations, current activities, moods, etc. In practice, thisallows researchers at remote locations, who may know nothing about thesystem of the present invention except its GUI, to immediately begin touse the system for their own applications. This is a highly effectiveway for collaborators to bootstrap.

The system of the present invention can also include several audiosubsystems. Such subsystems are used for generating speech and/or music,allowing actors to follow musical cues, and generating ambientbackground noise.

As disclosed, the system of the present invention allows actors andusers to interact with each other. An example of a scene involvingmultiple actors involved in a social interaction with a user will now bedescribed.

The following script sets forth a joke telling scenario involvingmultiple actors and a user:

define SCRIPT “Tell Joke” { {do “Turn to Face” to choose from {othersexcept player} } {cue {others except player} to “Listen To Joke” to me}{ do “No Soap, Radio” do “Joke Gestures” } {wait until {current “Joke”is “completed”}} {do “Laugh” for 3 seconds} {cue {others except player}to “React To Joke”} {wait 3 seconds} {do “React To Player”} }

In this example, the actor executing the script randomly chooses one ofthe actors not controlled by the user, and turns to the chosen actor.The actor then cues the other non-user actors to execute the “Listen ToJoke” script, in which the actor chooses the appropriate gestures andbody language that will give the appearance of listening attentively.

define SCRIPT “Listen To Joke” { { choose from { entire set of “Stances”} based on “appropriate listening gestures” choose from { entire set of“Gestures” } based on “appropriate listening gestures” } {continue forbetween 3 and 12 seconds} {repeat} }

In this case, the actor chooses from the actions in the sets “Stances”and “Gestures” using the decision rule “appropriate listening gestures”.

define DECISION_RULE “appropriate listening gestures” { subset“Listening?” scale 1 factor { my “confidence” is greater than its“confidence” to within 0.3 } influence .5 factor { my “self control” isless than its “self control” to within 0.3 } influence .5 } defineSUBSET “Listening?” {it is “reactive” and “conversational” or “generic”

In this decision rule, the actor narrows the list down to those actionsthat are reactive and conversational, or generic actions that can beused in any context. The rule then compares the “confidence” and “selfcontrol” of the actor to those assigned to each action, creating aweighted list favoring actions that match the fuzzy criteria. Afterchoosing from the list, the actor will wait from 3 to 12 seconds beforerepeating the script and choosing another gesture.

Meanwhile, the actor telling the joke then executes the “No Soap, Radio”script which contains a command to an external speech system to generatethe text of the joke. At the same time, the actor executes the “JokeGestures” script which, like the “Listen To Joke” script choosesappropriate gestures based on the actor's personality.

The actor continues until the joke is finished (i.e., the speechsubsystem sends a command to set the script's “completed” property totrue) and then laughs, cueing the other actors to execute the “React ToJoke” script.

define SCRIPT “React To Joke” { { choose from { “Laugh” “Giggle”“Ignore” “Get Upset”} based on “feelings toward player” } } defineDECISION_RULE “feelings toward player” { factor {my “sympathy toward”player does not equal its “mood” to within .4} }

Simply put, the more sympathy the actors have for the player, the lesslikely they are to react positively to the joke.

Finally, the actor executes the “React To Player” script in which theactor chooses an appropriate reaction to the player, depending onwhether or not the player tells his actor to laugh. If he does, the joketeller laughs, either maliciously, if her sympathy for the player islow, or playfully, if her sympathy for the player is high. If theplayer's actor doesn't laugh, the joke teller executes the “Get It?”script. This script taunts the player until he gets mad and/or leaves.

The system of the present invention can also operate in conjunction withvoice recognition. In one embodiment, an animated interactive embodiedactor can respond to spoken statements and requests. A voice recognitionsubsystem which can be used in conjunction with the system of thepresent invention is available from DialecTech. With such an embodiment,untrained participants can conduct a game, such as “Simon Says” with theactor. The actor will follow requests only if they are preceded by thewords “Simon Says”. To make it more interesting, the actor can beprogrammed so that sometimes he also follows requests not preceded by“Simon Says”, but then acts embarrassed at having been fooled. Suchinteraction increases the sense of psychological involvement by theparticipants. Participants appear to completely “buy into” the animatedactor's presence. This is likely due to several factors, namely, becausethe participants could talk with the actor directly, the participantsknow that the actor is not being puppeteered (being that the participantis the only human in the interaction loop), and because the actor'smotions are relatively lifelike and never repeat themselves precisely.

In a further embodiment, a user can be represented as an embodiedavatar, further enhancing the user's sense of fun, play, andinvolvement. The participant is presented with a large rear projectionof a room full of embodied conversational agents. The system includes anoverhead video camera which tracks the user's position and arm gestures.The user can be represented, for example, as a flying bat. As theparticipant walks around, the bat flies around accordingly. The nearestactor will, for instance, break out of conversing with other actors andbegin to interact with the bat. When the participant flaps her arms, thebat flies higher in the scene and the camera follows. This gives theparticipant a sense of soaring high in the air.

The system of the present invention is a useful tool for the embodimentof intelligent actors, especially for the study of social interaction.In particular, it is a good tool for building educational virtualreality environments, when used in conjunction with research softwarefor virtual interactive theater. The combination can be used to simulatebehaviors that would be likely to engage children to respond to,identify with, and learn from knowledge agents.

A further embodiment of the present invention includes extensions sothat animators can use commercial tools, such as Alias and SoftImage, tocreate small atomic animation components. Trained animators can usethese tools to build up content. Such content can include various walkcycles, sitting postures, head scratching, etc. The procedural animationsubsystem is designed in such a way that such action styles can beblended. For example, two or three different styles of walks can beseparately designed from a commercial key frame animation package andthen blended together. They can also be blended with various proceduralwalks, to create continuously variable walk styles that reflect theactor's current mood and attitude, as well as the animator's style.

In traditional animation, human motions are created from combinations oftemporarily overlapping gestures and stances. The system of the presentinvention can be used to tie into commercial animation tools to build upa library of component motions, and to classify these motions in a waythat makes them most useful as building blocks. The system of thepresent invention can also be embedded into a client-based applicationfor a Java compatible browser (such as Netscape Navigator version 2.0).

The system of the present invention can be implemented as a full 3Dsystem or as a “nearly 3D” system for lower-end applications. Thenearly-3D version can be implemented with a low-end platform, such as apersonal computer. The user can still be able to see a view into athree-dimensional world, but the visual representations of the actorsare simpler and largely two-dimensional. Furthermore, participants usingsystems with different capabilities (e.g., an SGI Onyx workstation andan Intel '486-based PC) can still interact in the same scene. Both userswould see the same actor, at the same location, performing the sameaction and having the same personality. The only difference would bethat the user with the higher performance system will see a much morerealistic quality of rendering.

In a further embodiment, the english-style behavioral sub-system can beintegrated with a voice recognition subsystem. This allows a user tofully exploit the object substrate and give access to the direction ofgoals, mood changes, attitudes and relationships between actors. Suchdirection can be provided via spoken sentences.

The method and system of the present invention is applicable to a widevariety of applications, including computer role playing games,simulated conferences, “clip animation,” graphical front ends for MUDs,synthetic performance, shared virtual worlds, interactive fiction,high-level direction for animation, digital puppetry, computer guidesand companions, point-to-point communication interfaces, and true,non-linear narrative television.

What is claimed is:
 1. A method for rendering at least one animatedactor, comprising the steps of: defining a first action for at least oneanimated actor; defining a second action for the at least one animatedactor; selecting at least one of the first action and the second actionvia a user input; and rendering the at least one animated as a functionof the user input, in real time, by layering at least one of the firstaction and the second action on top of the other one of the first actionand the second action, wherein the first action is modifiable as afunction of the second action when the first and second actions are bothbeing executed.
 2. The method according to claim 1, further comprisingthe step of: including at least one of the first action and the secondaction into at least one script, the at least one script including atleast one of a further action and a secondary script, wherein the atleast one animated actor is rendered as a further function of the atleast one script.
 3. The method according to claim 1, further comprisingthe steps of: grouping at least one first script and at least one secondscript into a first script group; and grouping at least one third scriptinto a second script group, wherein each script in the first scriptgroup and second script group includes at least one of a predeterminedaction and a predetermined secondary script.
 4. The method according toclaim 3, further comprising the step of: when a further script in one ofthe first script group and the second script group is selected,continuing an operation of another script of the other one of the firstscript group and the second script group in which the further script wasnot selected.
 5. The method according to claim 1, wherein the at leastone animated actor includes a set of personal characteristics, whereinthe at least one animated actor is surrounded by a rendered environment,the rendered environment having a set of environment characteristics,the method further comprising the steps of: defining a decision rule,the decision rule making a selection from a set of predetermined datacorresponding to at least one of the set of personal characteristics andthe set of environment characteristics; and rendering the animated actoras a further function of the selection.
 6. The method according to claim1, further comprising the steps of: defining a decision rule forselecting one of a set of predetermined data which corresponds to a setof possible actions; and rendering the animated actor as a furtherfunction of the selection.
 7. The method according to claim 1, whereinthe at least one animated actor includes a set of geometric shapesconnected by rotating joints.
 8. The method according to claim 7,wherein each one of the first action and the second action is defined bya set of time-varying degrees of freedom.
 9. The system according toclaim 1, wherein the user input is provided via a user interface.
 10. Amethod for rendering at least one animated actor, comprising the stepsof: defining a first action for at least one animated actor; defining asecond action for the at least one animated actor, selecting at leastone of the first action and the second action via a user input; andrendering the at least one animated as a function of the user input, inreal time, by layering at least one of the first action and the secondaction on top of the other one of the first action and the secondaction, wherein the at least one animated actor includes a first portionand a second portion, wherein the first portion includes a firstmovement of the first portion and a second movement of the secondportion, wherein the second action includes a third movement of thefirst portion, and wherein the second action is layered on top of thefirst action by transitioning from the first movement of the firstportion of the at least one animated actor to the third movement of thefirst portion without a necessity to return to an original position ofthe first movement.
 11. A method for rendering at least one animatedactor, comprising the steps of: defining a first action for at least oneanimated actor; defining a second action for the at least one animatedactor; selecting at least one of the first action and the second actionvia a user input; and rendering the at least one animated as a functionof the user input, in real time, by layering at least one of the firstaction and the second action on top of the other one of the first actionand the second action, wherein the at least one animated actor isrendered as a further function of a coherent noise.
 12. A method forrendering at least one animated actor, comprising the steps of: defininga first action for at least one animated actor; defining a second actionfor the at least one animated actor; selecting at least one of the firstaction and the second action via a user input; rendering the at leastone animated actor as a function of the user input, in real time, bylayering at least one of the first action and the second action on topof the other one of the first action and the second action; grouping atleast one first script and at least one second script into a firstscript group; grouping at least one third script into a second scriptgroup, wherein each script in the first script group and the secondscript group includes at least one predetermined action; and when afurther script in one of the first script group and the second scriptgroup is selected, terminating an operation of another script of thefirst script group and the second script group in which the furtherscript was selected.
 13. A method for rendering at least one animatedactor, comprising the steps of: defining a first action for at least oneanimated actor; defining a second action for the at least one animatedactor; selecting at least one of the first action and the second actionvia a user input; rendering the at least one animated actor as afunction of the user input, in real time, by layering at least one ofthe first action and the second action on top of the other one of thefirst action and the second action; grouping the first action and atleast one further first action into a first action group, each action ofthe first action group competing with another action of the first actiongroup to determine which one of the competing actions in the firstaction group is performed before the other one of the competing actions;and grouping the second action and at least one further second actioninto a second action group, each action of the second action groupcompeting with another action of the second action group to determinewhich one of the competing actions in the second action group isperformed before the other one of the competing actions.
 14. The methodaccording to claim 13, wherein any action of the second action group maybe layered on top of any other action of the first action group torender the at least one animated actor.
 15. The method according toclaim 14, further comprising the steps of: further rendering the atleast one animated actor as a function of one of the first action andthe at least one first further action by transitioning from the firstaction to the at least one first further action.
 16. A method forrendering at least one animated actor, comprising the steps of: defininga first action for at least one animated actor; defining a second actionfor the at least one animated actor; selecting at least one of the firstaction and the second action via a user input; rendering the at leastone animated actor as a function of the user input, in real time, bylayering at least one of the first action and the second action on topof the other one of the first action and the second action; providing auser with a visual list, the visual list containing a set of selectionscorresponding to a set of action; receiving a user input for selectingone of the set of actions; and further rendering the at least oneanimated actor as a function of the selected one of the set of actions.17. A system for rendering at least one animated actor, comprising: anoutput device; a processing device executing: a first instructiondefining a first action for at least one animated actor, and a secondinstruction defining a second action for at least one animated actor,and an input device receiving a user input for selecting at least one ofthe first action and the second action, the processing device renderingthe at least one animated actor via the output device as a function ofthe user input, in real time, by layering at least one of the firstaction and the second action on top of the other one of the first actionand the second action, wherein the processor is capable of modifying thefirst action as a function of the second action when the first andsecond actions are both being executed.
 18. The system according toclaim 17, further comprising: a storage device storing the at least oneof the first action and the second action into at least one script, theat least one script including at least one of a further action and asecondary script, wherein the processing device renders the at least oneanimated actor as a further function of the-at least one script.
 19. Thesystem according to claim 17, further comprising: a storage devicestoring at least one first script and at least one second script into afirst script group and at least one third script into a second scriptgroup, wherein each script in the first script group and second scriptgroup includes at least one of a predetermined action and apredetermined secondary script.
 20. The system according to claim 19,wherein, when a further script in one of the first script group and thesecond script group is selected, the processing device continues anoperation of another script of the other one of the first script groupand the second script group in which the further script was notselected.
 21. The system according to claim 17, wherein the at least oneanimated actor includes a set of personal characteristics, wherein theat least one animated actor is surrounded by a rendered environment, therendered environment having a set of environment characteristics, thesystem further comprising: a storage device storing a decision rule, thedecision rule making a selection from a set of predetermined datacorresponding to at least one of the set of personal characteristics andthe set of environment characteristics, wherein the processing devicerenders the animated actor as a further function of the selection. 22.The system according to claim 17, further comprising: a storage devicestoring a decision rule for selecting one of a set of predetermined datawhich corresponds to a set of possible actions, wherein the processingdevice renders the animated actor as a further function of theselection.
 23. The system according to claim 17, wherein the at leastone animated actor includes a set of geometric shapes connected byrotating joints.
 24. The system according to claim 17, wherein each oneof the first action and the second action is defined by a set oftime-varying degrees of freedom.
 25. The system according to claim 17,further comprising: a communications apparatus connecting the processingdevice to at least one further processing device which renders a furtheranimated actor.
 26. The system according to claim 25, wherein thecommunications apparatus includes at least one of a modem, a local areanetwork, a wide area network, an Intranet, and an Internet communicationsystem.
 27. The system according to claim 25, wherein the processingdevice executes instructions utilizing a UNIX operating system.
 28. Thesystem according to claim 25, wherein the processing device and the atleast one further processing device communicate via a blackboard. 29.The system according to claim 17, wherein the user device receives theuser input that is provided via a user interface.
 30. A system forrendering at least one animated actor, comprising: an output device; aprocessing device executing: a first instruction defining a first actionfor at least one animated actor, and a second instruction defining asecond action for at least one animated actor; and an input devicereceiving a user input for selecting at least one of the first actionand the second action, the processing device rendering the at least oneanimated actor via the output device as a function of the user input, inreal time, by layering at least one of the first action and the secondaction on top of the other one of the first action and the secondaction, wherein the at least one animated actor includes a first portionand a second portion, wherein the first portion includes a firstmovement of the first portion and a second movement of the secondportion, wherein the second action includes a third movement of thefirst portion, and wherein the second action is layered on top of thefirst action by transitioning from the first movement of the firstportion of the at least one animated actor to the third movement of thefirst portion without a necessity to return to an original position ofthe first movement.
 31. A system for rendering at least one animatedactor, comprising: an output device; a processing device executing: afirst instruction defining a first action for at least one animatedactor, and a second instruction defining a second action for at leastone animated actor; and an input device receiving a user input forselecting at least one of the first action and the second action, theprocessing device rendering the at least one animated actor via theoutput device as a function of the user input, in real time, by layeringat least one of the first action and the second action on top of theother one of the first action and the second action, wherein theprocessing device renders the at least one animator actor as a furtherfunction of a coherent noise.
 32. A system for rendering at least oneanimated actor, comprising: an output device; a processing deviceexecuting: a first instruction defining a first action for at least oneanimated actor, and a second instruction defining a second action for atleast one animated actor, an input device receiving a user input forselecting at least one of the first action and the second action, theprocessing device rendering the at least one animated actor via theoutput device as a function of the user input, in real time, by layeringat least one of the first action and the second action on top of theother one of the first action and the second action; and a storagedevice storing at least one first script and at least one second scriptinto a first script group, and at least one third script into a secondscript group, wherein each script in the first script group and thesecond script group includes at least one predetermined action, andwherein, when a further script in one of the first script group and thesecond script group is selected, the processing device terminates anoperation of another script of the first script group and the secondscript group in which the further script was selected.
 33. A system forrendering at least one animated actor, comprising: an output device; aprocessing device executing: a first instruction defining a first actionfor at least one animated actor, and a second instruction defining asecond action for at least one animated actor; an input device receivinga user input for selecting at least one of the first action and thesecond action, the processing device rendering the at least one animatedactor via the output device as a function of the user input, in realtime, by layering at least one of the first action and the second actionon top of the other one of the first action and the second action; and astorage device storing the first action and at least one further firstaction into a first action group, each action of the first action groupcompeting with another action of the first action group to determinewhich one of the competing actions in the first action group isperformed before the other one of the competing actions, the storagedevice further storing the second action and at least one further secondaction into a second action group, each action of the second actiongroup competing with another action of the second action group todetermine which one of the competing actions in the second action groupis performed before the other one of the competing actions.
 34. Thesystem according to claim 33, wherein any action of the second actiongroup is capable of being layered on top of any other action of thefirst action group to render the at least one animated actor.
 35. Thesystem according to claim 34, wherein the processing device furtherrenders the at least one animated actor as a function of one of thefirst action and the at least one first further action by transitioningfrom the first action to the at least one first further action.
 36. Asystem for rendering at least one animated actor, comprising: an outputdevice; a processing device executing: a first instruction defining afirst action for at least one animated actor, and a second instructiondefining a second action for at least one animated actor; and an inputdevice receiving a user input for selecting at least one of the firstaction and the second action, the processing device rendering the atleast one animated actor via the output device as a function of the userinput, in real time, by layering at least one of the first action andthe second action on top of the other one of the first action and thesecond action, wherein the processing device provides a user with avisual list, the visual list including a set of selections whichcorrespond to a set of actions, wherein the input device receives theuser input for selecting one of the set of actions, and wherein theprocessing device further renders the at least one animated character asa function of the selected one of the set of actions.
 37. A method forrendering at least one animated actor, comprising the steps of:providing a library of predetermined actions for executing a firstaction; providing at least one script which includes at least one of asecond action and a secondary script; via a user interface, visuallyproviding a set of selections corresponding to at least one of thelibrary of predetermined actions and the at least one script; selecting,via a user input, at least one member of the set of selections that isvisually provided on the user interface; and rendering the at least oneanimated actor, in real time, as a function of the at least one selectedmember of the set of selections.
 38. The method according to claim 37,wherein the set of selections correspond to the first action and the atleast one script.
 39. The method according to claim 37, wherein, beforethe at least one selected member of the set of selections is selected,the at least one animated actor is rendered to perform an initialaction, and wherein, after the at least one selected member of the setof selections is selected, at least one of the first action and the atleast one script is layered relative to the initial action to render theat least one animated actor.
 40. The method according to claim 37,wherein the at least one selected member includes at least two selectedmembers, wherein the at least one animated actor is rendered by layeringactions corresponding to the at least two members on top of one other,and wherein at least one of the actions corresponding to the at leasttwo selected members is capable of being modified based on another oneof the actions corresponding to the at least two selected members whenthe corresponding actions are both being executed.